﻿#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
using namespace std;
//namespace bit
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		typedef const char* const_iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//		iterator end()
//		{
//			return _str + _size;
//		}
//		const_iterator begin() const
//		{
//			return _str;
//		}
//		const_iterator end() const
//		{
//			return _str + _size;
//		}
//		string(const char* str = "")
//			:_size(strlen(str))
//			, _capacity(_size)
//		{
//			cout << "string(char* str)-构造" << endl;
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);
//		}
//		void swap(string& s)
//		{
//			::swap(_str, s._str);
//			::swap(_size, s._size);
//			::swap(_capacity, s._capacity);
//		}
//		string(const string& s)
//			:_str(nullptr)
//		{
//			cout << "string(const string& s) -- 拷⻉构造" << endl;
//			reserve(s._capacity);
//			for (auto ch : s)
//			{
//				push_back(ch);
//			}
//		}
//		// 移动构造
//		string(string&& s)
//		{
//			cout << "string(string&& s) -- 移动构造" << endl;
//			swap(s);
//		}
//		string& operator=(const string& s)
//		{
//			cout << "string& operator=(const string& s) -- 拷⻉赋值" <<
//				endl;
//			if (this != &s)
//			{
//				_str[0] = '\0';
//				_size = 0;
//				reserve(s._capacity);
//				for (auto ch : s)
//				{
//					push_back(ch);
//				}
//			}
//			return *this;
//		}
//		// 移动赋值
//		string& operator=(string&& s)
//		{
//			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
//			swap(s);
//			return *this;
//		}
//		~string()
//		{
//			cout << "~string() -- 析构" << endl;
//			delete[] _str;
//			_str = nullptr;
//		}
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				if (_str)
//				{
//					strcpy(tmp, _str);
//					delete[] _str;
//				}
//				_str = tmp;
//				_capacity = n;
//			}
//		}
//		void push_back(char ch)
//		{
//			if (_size >= _capacity)
//			{
//				size_t newcapacity = _capacity == 0 ? 4 : _capacity *2;
//				reserve(newcapacity);
//			}
//			_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';
//		}
//		string& operator+=(char ch)
//		{
//			push_back(ch);
//			return *this;
//		}
//		const char* c_str() const
//		{
//			return _str;
//		}
//
//		size_t size() const
//		{
//			return _size;
//		}
//private:
//	char* _str = nullptr;
//	size_t _size = 0;
//	size_t _capacity = 0;
//};
//}
//int main()
//{
//	bit::string s1("xxxxx");
//	// 拷⻉构造
//	bit::string s2 = s1;
//	// 构造+移动构造，优化后直接构造
//	bit::string s3 = bit::string("yyyyy");
//	// 移动构造
//	bit::string s4 = move(s1);
//	cout << "******************************" << endl;
//	return 0;
//}
//
//namespace bit
//{
//	string addStrings(string num1, string num2)
//	{
//		string str;
//		int end1 = num1.size() - 1, end2 = num2.size() - 1;
//		int next = 0;
//		while (end1 >= 0 || end2 >= 0)
//		{
//			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
//			int ret = val1 + val2 + next;
//			next = ret / 10;
//			ret = ret % 10;
//			str += ('0' + ret);
//		}
//		if (next == 1)
//			str += '1';
//		reverse(str.begin(), str.end());
//		cout << "******************************" << endl;
//		return str;
//	}
//}
//// 场景1
//int main()
//{
//	bit::string ret = bit::addStrings("11111", "2222");
//	cout << ret.c_str() << endl;
//	return 0;
//}
//// 场景2
//int main()
//{
//	bit::string ret;
//	ret = bit::addStrings("11111", "2222");
//	cout << ret.c_str() << endl;
//	return 0;
//}

//int main()
//{
//	list<string> lt;
//	cout << "*************************" << endl;
//	string s1("111111111111111111111");
//	lt.push_back(s1);
//	cout << "*************************" << endl;
//	lt.push_back(string("22222222222222222222222222222"));
//	cout << "*************************" << endl;
//	lt.push_back("3333333333333333333333333333");
//	cout << "*************************" << endl;
//	lt.push_back(move(s1));
//	cout << "*************************" << endl;
//	return 0;
//}


template<class ...Args>
void Print(Args&&... args)
{
	cout <<sizeof ...(args) << endl;
}


//void Print();
//void Print(int&& arg1);
//void Print(int&& arg1, string&& arg2);
//void Print(double&& arg1, string&& arg2, double& arg3);
//
//
//void Print();
//template <class T1>
//void Print(T1&& arg1);
//template <class T1, class T2>
//void Print(T1&& arg1, T2&& arg2);
//template <class T1, class T2, class T3>
//void Print(T1&& arg1, T2&& arg2, T3&& arg3);
//
//
//int main()
//{
//	Print(100);
//	Print(1.1);
//	Print(1, string("sdhja"), char("1"));
//	return 0;
//}

//void Showlist()
//{
//	cout << endl;
//}
//template<class T,class ...Args>
//void Showlist(T x, Args... args)
//{
//	cout << x << " ";
//	Showlist(args...);
//}
//template<class ...Args>
//void Paint(Args... args)
//{
//	Showlist(args...);
//}
//
//int main()
//{
//	Paint(1, string("xxxxx"),2.3);
//	return 0;
//}
//
//void ShowList()
//{
//	cout << endl;
//}
//template<class T,class ...Args>
//void ShowList(T x,Args... args)
//{
//	cout << x << " ";
//	ShowList(args...);
//}
//template<class ...Args>
//void Pint(Args... args)
//{
//	ShowList(args...);
//}
//
//void ShowList()
//{
//	cout << endl;
//}
//
//template<class T,class ...Args>
//void ShowList(T x, Args... args)
//{
//	cout << x << " ";
//	ShowList(args...);
//}
//
//template<class ...Args>
//void Paint(Args... args)
//{
//	ShowList(args...);
//}



// emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
//int main()
//{
//	list<string> lt;
//	// 传左值，跟push_back一样，走拷贝构造
//	string s1("111111111111");
//	lt.emplace_back(s1);
//	cout << "*********************************" << endl;
//	// 右值，跟push_back一样，走移动构造
//	lt.emplace_back(move(s1));
//	cout << "*********************************" << endl;
//	// 直接把构造string参数包往下传，直接用string参数包构造string
//	// 这里达到的效果是push_back做不到的
//	lt.emplace_back("111111111111");
//	cout << "*********************************" << endl;
//	list<pair<string, int>> lt1;
//	// 跟push_back一样
//	// 构造pair + 拷贝/移动构造pair到list的节点中data上
//	pair<string, int> kv("苹果", 1);
//	lt1.emplace_back(kv);
//	cout << "*********************************" << endl;
//	// 跟push_back一样
//	lt1.emplace_back(move(kv));
//	cout << "*********************************" << endl;
//	////////////////////////////////////////////////////////////////////
//	// 直接把构造pair参数包往下传，直接用pair参数包构造pair
//	// 这里达到的效果是push_back做不到的
//	lt1.emplace_back("苹果", 1);
//	cout << "*********************************" << endl;
//	return 0;
//}